YES 3.513 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ BR

mainModule List
  ((nub :: Eq a => [a ->  [a]) :: Eq a => [a ->  [a])

module List where
  import qualified Maybe
import qualified Prelude

  nub :: Eq a => [a ->  [a]
nub l 
nub' l [] where 
nub' [] _ []
nub' (x : xsls 
 | x `elem` ls = 
nub' xs ls
 | otherwise = 
x : nub' xs (x : ls)


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ BR
HASKELL
      ↳ COR

mainModule List
  ((nub :: Eq a => [a ->  [a]) :: Eq a => [a ->  [a])

module List where
  import qualified Maybe
import qualified Prelude

  nub :: Eq a => [a ->  [a]
nub l 
nub' l [] where 
nub' [] vw []
nub' (x : xsls 
 | x `elem` ls = 
nub' xs ls
 | otherwise = 
x : nub' xs (x : ls)


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
nub' [] vw = []
nub' (x : xsls
 | x `elem` ls
 = nub' xs ls
 | otherwise
 = x : nub' xs (x : ls)

is transformed to
nub' [] vw = nub'3 [] vw
nub' (x : xsls = nub'2 (x : xsls

nub'1 x xs ls True = nub' xs ls
nub'1 x xs ls False = nub'0 x xs ls otherwise

nub'0 x xs ls True = x : nub' xs (x : ls)

nub'2 (x : xsls = nub'1 x xs ls (x `elem` ls)

nub'3 [] vw = []
nub'3 xz yu = nub'2 xz yu

The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ BR
    ↳ HASKELL
      ↳ COR
HASKELL
          ↳ LetRed

mainModule List
  ((nub :: Eq a => [a ->  [a]) :: Eq a => [a ->  [a])

module List where
  import qualified Maybe
import qualified Prelude

  nub :: Eq a => [a ->  [a]
nub l 
nub' l [] where 
nub' [] vw nub'3 [] vw
nub' (x : xsls nub'2 (x : xs) ls
nub'0 x xs ls True x : nub' xs (x : ls)
nub'1 x xs ls True nub' xs ls
nub'1 x xs ls False nub'0 x xs ls otherwise
nub'2 (x : xsls nub'1 x xs ls (x `elem` ls)
nub'3 [] vw []
nub'3 xz yu nub'2 xz yu


module Maybe where
  import qualified List
import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
nub' l []
where 
nub' [] vw = nub'3 [] vw
nub' (x : xsls = nub'2 (x : xsls
nub'0 x xs ls True = x : nub' xs (x : ls)
nub'1 x xs ls True = nub' xs ls
nub'1 x xs ls False = nub'0 x xs ls otherwise
nub'2 (x : xsls = nub'1 x xs ls (x `elem` ls)
nub'3 [] vw = []
nub'3 xz yu = nub'2 xz yu

are unpacked to the following functions on top level
nubNub' [] vw = nubNub'3 [] vw
nubNub' (x : xsls = nubNub'2 (x : xsls

nubNub'0 x xs ls True = x : nubNub' xs (x : ls)

nubNub'2 (x : xsls = nubNub'1 x xs ls (x `elem` ls)

nubNub'1 x xs ls True = nubNub' xs ls
nubNub'1 x xs ls False = nubNub'0 x xs ls otherwise

nubNub'3 [] vw = []
nubNub'3 xz yu = nubNub'2 xz yu



↳ HASKELL
  ↳ BR
    ↳ HASKELL
      ↳ COR
        ↳ HASKELL
          ↳ LetRed
HASKELL
              ↳ Narrow

mainModule List
  (nub :: Eq a => [a ->  [a])

module List where
  import qualified Maybe
import qualified Prelude

  nub :: Eq a => [a ->  [a]
nub l nubNub' l []

  
nubNub' [] vw nubNub'3 [] vw
nubNub' (x : xsls nubNub'2 (x : xs) ls

  
nubNub'0 x xs ls True x : nubNub' xs (x : ls)

  
nubNub'1 x xs ls True nubNub' xs ls
nubNub'1 x xs ls False nubNub'0 x xs ls otherwise

  
nubNub'2 (x : xsls nubNub'1 x xs ls (x `elem` ls)

  
nubNub'3 [] vw []
nubNub'3 xz yu nubNub'2 xz yu


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ BR
    ↳ HASKELL
      ↳ COR
        ↳ HASKELL
          ↳ LetRed
            ↳ HASKELL
              ↳ Narrow
                ↳ AND
QDP
                    ↳ QDPSizeChangeProof
                  ↳ QDP
                  ↳ QDP
                  ↳ QDP
                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primPlusNat(Succ(yv36000), Succ(yv3321000)) → new_primPlusNat(yv36000, yv3321000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ BR
    ↳ HASKELL
      ↳ COR
        ↳ HASKELL
          ↳ LetRed
            ↳ HASKELL
              ↳ Narrow
                ↳ AND
                  ↳ QDP
QDP
                    ↳ QDPSizeChangeProof
                  ↳ QDP
                  ↳ QDP
                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat(Succ(yv328100), Succ(yv332100)) → new_primMulNat(yv328100, Succ(yv332100))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ BR
    ↳ HASKELL
      ↳ COR
        ↳ HASKELL
          ↳ LetRed
            ↳ HASKELL
              ↳ Narrow
                ↳ AND
                  ↳ QDP
                  ↳ QDP
QDP
                    ↳ QDPSizeChangeProof
                  ↳ QDP
                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primEqNat(Succ(yv32800), Succ(yv33200)) → new_primEqNat(yv32800, yv33200)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ BR
    ↳ HASKELL
      ↳ COR
        ↳ HASKELL
          ↳ LetRed
            ↳ HASKELL
              ↳ Narrow
                ↳ AND
                  ↳ QDP
                  ↳ QDP
                  ↳ QDP
QDP
                    ↳ QDPSizeChangeProof
                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_esEs0(@2(yv3280, yv3281), @2(yv3320, yv3321), app(app(app(ty_@3, cg), da), db), cc) → new_esEs2(yv3280, yv3320, cg, da, db)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), app(app(app(ty_@3, gh), ha), hb), gc, gd) → new_esEs2(yv3280, yv3320, gh, ha, hb)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), he, app(app(ty_@2, hg), hh), gd) → new_esEs0(yv3281, yv3321, hg, hh)
new_esEs0(@2(yv3280, yv3281), @2(yv3320, yv3321), de, app(app(app(ty_@3, eb), ec), ed)) → new_esEs2(yv3281, yv3321, eb, ec, ed)
new_esEs0(@2(yv3280, yv3281), @2(yv3320, yv3321), app(app(ty_Either, dc), dd), cc) → new_esEs3(yv3280, yv3320, dc, dd)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), he, app(app(ty_Either, bae), baf), gd) → new_esEs3(yv3281, yv3321, bae, baf)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), he, gc, app(app(ty_@2, bah), bba)) → new_esEs0(yv3282, yv3322, bah, bba)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), he, app(ty_Maybe, hf), gd) → new_esEs(yv3281, yv3321, hf)
new_esEs3(Right(yv3280), Right(yv3320), bdb, app(app(ty_Either, beb), bec)) → new_esEs3(yv3280, yv3320, beb, bec)
new_esEs1(:(yv3280, yv3281), :(yv3320, yv3321), ga) → new_esEs1(yv3281, yv3321, ga)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), app(app(ty_@2, ge), gf), gc, gd) → new_esEs0(yv3280, yv3320, ge, gf)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), he, app(ty_[], baa), gd) → new_esEs1(yv3281, yv3321, baa)
new_esEs0(@2(yv3280, yv3281), @2(yv3320, yv3321), app(ty_[], cf), cc) → new_esEs1(yv3280, yv3320, cf)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), he, gc, app(ty_Maybe, bag)) → new_esEs(yv3282, yv3322, bag)
new_esEs1(:(yv3280, yv3281), :(yv3320, yv3321), app(ty_[], fb)) → new_esEs1(yv3280, yv3320, fb)
new_esEs(Just(yv3280), Just(yv3320), app(app(app(ty_@3, be), bf), bg)) → new_esEs2(yv3280, yv3320, be, bf, bg)
new_esEs(Just(yv3280), Just(yv3320), app(ty_Maybe, ba)) → new_esEs(yv3280, yv3320, ba)
new_esEs0(@2(yv3280, yv3281), @2(yv3320, yv3321), de, app(app(ty_Either, ee), ef)) → new_esEs3(yv3281, yv3321, ee, ef)
new_esEs3(Left(yv3280), Left(yv3320), app(app(ty_Either, bch), bda), bca) → new_esEs3(yv3280, yv3320, bch, bda)
new_esEs1(:(yv3280, yv3281), :(yv3320, yv3321), app(app(ty_Either, fg), fh)) → new_esEs3(yv3280, yv3320, fg, fh)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), app(ty_Maybe, gb), gc, gd) → new_esEs(yv3280, yv3320, gb)
new_esEs(Just(yv3280), Just(yv3320), app(app(ty_@2, bb), bc)) → new_esEs0(yv3280, yv3320, bb, bc)
new_esEs3(Left(yv3280), Left(yv3320), app(app(ty_@2, bcb), bcc), bca) → new_esEs0(yv3280, yv3320, bcb, bcc)
new_esEs1(:(yv3280, yv3281), :(yv3320, yv3321), app(ty_Maybe, eg)) → new_esEs(yv3280, yv3320, eg)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), app(app(ty_Either, hc), hd), gc, gd) → new_esEs3(yv3280, yv3320, hc, hd)
new_esEs3(Right(yv3280), Right(yv3320), bdb, app(app(ty_@2, bdd), bde)) → new_esEs0(yv3280, yv3320, bdd, bde)
new_esEs3(Right(yv3280), Right(yv3320), bdb, app(ty_[], bdf)) → new_esEs1(yv3280, yv3320, bdf)
new_esEs(Just(yv3280), Just(yv3320), app(ty_[], bd)) → new_esEs1(yv3280, yv3320, bd)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), he, app(app(app(ty_@3, bab), bac), bad), gd) → new_esEs2(yv3281, yv3321, bab, bac, bad)
new_esEs0(@2(yv3280, yv3281), @2(yv3320, yv3321), app(ty_Maybe, cb), cc) → new_esEs(yv3280, yv3320, cb)
new_esEs0(@2(yv3280, yv3281), @2(yv3320, yv3321), de, app(ty_Maybe, df)) → new_esEs(yv3281, yv3321, df)
new_esEs3(Right(yv3280), Right(yv3320), bdb, app(app(app(ty_@3, bdg), bdh), bea)) → new_esEs2(yv3280, yv3320, bdg, bdh, bea)
new_esEs(Just(yv3280), Just(yv3320), app(app(ty_Either, bh), ca)) → new_esEs3(yv3280, yv3320, bh, ca)
new_esEs0(@2(yv3280, yv3281), @2(yv3320, yv3321), app(app(ty_@2, cd), ce), cc) → new_esEs0(yv3280, yv3320, cd, ce)
new_esEs3(Right(yv3280), Right(yv3320), bdb, app(ty_Maybe, bdc)) → new_esEs(yv3280, yv3320, bdc)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), he, gc, app(ty_[], bbb)) → new_esEs1(yv3282, yv3322, bbb)
new_esEs3(Left(yv3280), Left(yv3320), app(app(app(ty_@3, bce), bcf), bcg), bca) → new_esEs2(yv3280, yv3320, bce, bcf, bcg)
new_esEs0(@2(yv3280, yv3281), @2(yv3320, yv3321), de, app(ty_[], ea)) → new_esEs1(yv3281, yv3321, ea)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), he, gc, app(app(ty_Either, bbf), bbg)) → new_esEs3(yv3282, yv3322, bbf, bbg)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), app(ty_[], gg), gc, gd) → new_esEs1(yv3280, yv3320, gg)
new_esEs3(Left(yv3280), Left(yv3320), app(ty_[], bcd), bca) → new_esEs1(yv3280, yv3320, bcd)
new_esEs1(:(yv3280, yv3281), :(yv3320, yv3321), app(app(app(ty_@3, fc), fd), ff)) → new_esEs2(yv3280, yv3320, fc, fd, ff)
new_esEs0(@2(yv3280, yv3281), @2(yv3320, yv3321), de, app(app(ty_@2, dg), dh)) → new_esEs0(yv3281, yv3321, dg, dh)
new_esEs3(Left(yv3280), Left(yv3320), app(ty_Maybe, bbh), bca) → new_esEs(yv3280, yv3320, bbh)
new_esEs1(:(yv3280, yv3281), :(yv3320, yv3321), app(app(ty_@2, eh), fa)) → new_esEs0(yv3280, yv3320, eh, fa)
new_esEs2(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), he, gc, app(app(app(ty_@3, bbc), bbd), bbe)) → new_esEs2(yv3282, yv3322, bbc, bbd, bbe)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ BR
    ↳ HASKELL
      ↳ COR
        ↳ HASKELL
          ↳ LetRed
            ↳ HASKELL
              ↳ Narrow
                ↳ AND
                  ↳ QDP
                  ↳ QDP
                  ↳ QDP
                  ↳ QDP
QDP
                    ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_nubNub'1(yv328, yv329, yv330, yv331, yv332, yv333, ba) → new_nubNub'10(yv328, yv329, yv330, yv331, new_esEs4(yv328, yv332, ba), yv333, ba)
new_nubNub'10(yv341, yv342, yv343, yv344, False, :(yv3460, yv3461), bb) → new_nubNub'1(yv341, yv342, yv343, yv344, yv3460, yv3461, bb)
new_nubNub'10(yv341, yv342, yv343, yv344, False, [], bb) → new_nubNub'(yv342, yv341, :(yv343, yv344), bb)
new_nubNub'10(yv341, :(yv3420, yv3421), yv343, yv344, True, yv346, bb) → new_nubNub'11(yv3420, yv3421, yv343, yv344, bb)
new_nubNub'(:(yv3420, yv3421), yv343, yv344, bb) → new_nubNub'11(yv3420, yv3421, yv343, yv344, bb)
new_nubNub'11(yv234, yv235, yv236, yv237, bc) → new_nubNub'1(yv234, yv235, yv236, yv237, yv236, yv237, bc)

The TRS R consists of the following rules:

new_esEs23(yv3281, yv3321, ty_Integer) → new_esEs13(yv3281, yv3321)
new_esEs25(yv3280, yv3320, app(app(app(ty_@3, bbg), bbh), bca)) → new_esEs16(yv3280, yv3320, bbg, bbh, bca)
new_primEqInt(Pos(Succ(yv32800)), Neg(yv3320)) → False
new_primEqInt(Neg(Succ(yv32800)), Pos(yv3320)) → False
new_esEs4(yv328, yv332, ty_@0) → new_esEs6(yv328, yv332)
new_esEs21(yv3280, yv3320, ty_Ordering) → new_esEs12(yv3280, yv3320)
new_esEs20(yv3281, yv3321, ty_Integer) → new_esEs13(yv3281, yv3321)
new_esEs17(Right(yv3280), Right(yv3320), fa, ty_Double) → new_esEs10(yv3280, yv3320)
new_esEs24(yv3282, yv3322, ty_Char) → new_esEs9(yv3282, yv3322)
new_primEqInt(Pos(Zero), Neg(Succ(yv33200))) → False
new_primEqInt(Neg(Zero), Pos(Succ(yv33200))) → False
new_esEs24(yv3282, yv3322, ty_Ordering) → new_esEs12(yv3282, yv3322)
new_esEs4(yv328, yv332, ty_Int) → new_esEs18(yv328, yv332)
new_esEs5(Just(yv3280), Just(yv3320), ty_Float) → new_esEs8(yv3280, yv3320)
new_esEs5(Just(yv3280), Just(yv3320), app(ty_[], ca)) → new_esEs15(yv3280, yv3320, ca)
new_esEs17(Right(yv3280), Right(yv3320), fa, ty_Ordering) → new_esEs12(yv3280, yv3320)
new_esEs23(yv3281, yv3321, ty_Int) → new_esEs18(yv3281, yv3321)
new_esEs23(yv3281, yv3321, ty_Bool) → new_esEs11(yv3281, yv3321)
new_esEs25(yv3280, yv3320, app(app(ty_@2, bbd), bbe)) → new_esEs14(yv3280, yv3320, bbd, bbe)
new_primMulNat0(Zero, Zero) → Zero
new_esEs24(yv3282, yv3322, ty_Integer) → new_esEs13(yv3282, yv3322)
new_esEs17(Right(yv3280), Left(yv3320), fa, fb) → False
new_esEs17(Left(yv3280), Right(yv3320), fa, fb) → False
new_esEs17(Left(yv3280), Left(yv3320), ty_Float, fb) → new_esEs8(yv3280, yv3320)
new_esEs21(yv3280, yv3320, ty_Double) → new_esEs10(yv3280, yv3320)
new_esEs26(yv3281, yv3321, app(ty_Ratio, bcd)) → new_esEs7(yv3281, yv3321, bcd)
new_esEs22(yv3280, yv3320, ty_Char) → new_esEs9(yv3280, yv3320)
new_esEs12(GT, EQ) → False
new_esEs12(EQ, GT) → False
new_esEs4(yv328, yv332, ty_Ordering) → new_esEs12(yv328, yv332)
new_esEs21(yv3280, yv3320, app(ty_[], df)) → new_esEs15(yv3280, yv3320, df)
new_esEs4(yv328, yv332, app(ty_[], da)) → new_esEs15(yv328, yv332, da)
new_esEs24(yv3282, yv3322, ty_@0) → new_esEs6(yv3282, yv3322)
new_esEs21(yv3280, yv3320, ty_Integer) → new_esEs13(yv3280, yv3320)
new_esEs24(yv3282, yv3322, app(ty_Ratio, hh)) → new_esEs7(yv3282, yv3322, hh)
new_esEs17(Right(yv3280), Right(yv3320), fa, ty_Char) → new_esEs9(yv3280, yv3320)
new_esEs26(yv3281, yv3321, ty_Int) → new_esEs18(yv3281, yv3321)
new_sr(Pos(yv32810), Neg(yv33210)) → Neg(new_primMulNat0(yv32810, yv33210))
new_sr(Neg(yv32810), Pos(yv33210)) → Neg(new_primMulNat0(yv32810, yv33210))
new_esEs17(Left(yv3280), Left(yv3320), ty_Char, fb) → new_esEs9(yv3280, yv3320)
new_esEs19(yv3280, yv3320, ty_Int) → new_esEs18(yv3280, yv3320)
new_esEs12(GT, LT) → False
new_esEs12(LT, GT) → False
new_esEs21(yv3280, yv3320, ty_@0) → new_esEs6(yv3280, yv3320)
new_esEs24(yv3282, yv3322, app(ty_Maybe, baa)) → new_esEs5(yv3282, yv3322, baa)
new_esEs23(yv3281, yv3321, ty_@0) → new_esEs6(yv3281, yv3321)
new_esEs20(yv3281, yv3321, ty_Int) → new_esEs18(yv3281, yv3321)
new_esEs22(yv3280, yv3320, ty_Bool) → new_esEs11(yv3280, yv3320)
new_esEs4(yv328, yv332, ty_Bool) → new_esEs11(yv328, yv332)
new_esEs5(Just(yv3280), Just(yv3320), app(ty_Maybe, bf)) → new_esEs5(yv3280, yv3320, bf)
new_esEs4(yv328, yv332, app(app(app(ty_@3, ef), eg), eh)) → new_esEs16(yv328, yv332, ef, eg, eh)
new_esEs15(:(yv3280, yv3281), :(yv3320, yv3321), da) → new_asAs(new_esEs21(yv3280, yv3320, da), new_esEs15(yv3281, yv3321, da))
new_esEs5(Just(yv3280), Just(yv3320), ty_Char) → new_esEs9(yv3280, yv3320)
new_esEs4(yv328, yv332, ty_Integer) → new_esEs13(yv328, yv332)
new_esEs17(Left(yv3280), Left(yv3320), ty_Ordering, fb) → new_esEs12(yv3280, yv3320)
new_primEqNat0(Zero, Succ(yv33200)) → False
new_primEqNat0(Succ(yv32800), Zero) → False
new_primPlusNat0(Zero, Zero) → Zero
new_esEs17(Left(yv3280), Left(yv3320), app(app(ty_@2, bdh), bea), fb) → new_esEs14(yv3280, yv3320, bdh, bea)
new_esEs22(yv3280, yv3320, app(app(ty_@2, ff), fg)) → new_esEs14(yv3280, yv3320, ff, fg)
new_esEs22(yv3280, yv3320, ty_Ordering) → new_esEs12(yv3280, yv3320)
new_esEs24(yv3282, yv3322, ty_Double) → new_esEs10(yv3282, yv3322)
new_esEs5(Just(yv3280), Just(yv3320), app(ty_Ratio, be)) → new_esEs7(yv3280, yv3320, be)
new_esEs23(yv3281, yv3321, app(app(app(ty_@3, hc), hd), he)) → new_esEs16(yv3281, yv3321, hc, hd, he)
new_primEqInt(Pos(Zero), Pos(Zero)) → True
new_esEs24(yv3282, yv3322, app(app(app(ty_@3, bae), baf), bag)) → new_esEs16(yv3282, yv3322, bae, baf, bag)
new_esEs21(yv3280, yv3320, app(app(ty_@2, dd), de)) → new_esEs14(yv3280, yv3320, dd, de)
new_esEs5(Just(yv3280), Just(yv3320), ty_@0) → new_esEs6(yv3280, yv3320)
new_esEs17(Right(yv3280), Right(yv3320), fa, ty_Int) → new_esEs18(yv3280, yv3320)
new_esEs25(yv3280, yv3320, ty_Float) → new_esEs8(yv3280, yv3320)
new_esEs21(yv3280, yv3320, app(app(ty_Either, eb), ec)) → new_esEs17(yv3280, yv3320, eb, ec)
new_esEs17(Left(yv3280), Left(yv3320), app(app(ty_Either, bef), beg), fb) → new_esEs17(yv3280, yv3320, bef, beg)
new_esEs26(yv3281, yv3321, app(ty_Maybe, bce)) → new_esEs5(yv3281, yv3321, bce)
new_esEs4(yv328, yv332, app(ty_Maybe, bd)) → new_esEs5(yv328, yv332, bd)
new_primPlusNat1(Succ(yv3600), yv332100) → Succ(Succ(new_primPlusNat0(yv3600, yv332100)))
new_esEs24(yv3282, yv3322, app(app(ty_@2, bab), bac)) → new_esEs14(yv3282, yv3322, bab, bac)
new_esEs21(yv3280, yv3320, app(app(app(ty_@3, dg), dh), ea)) → new_esEs16(yv3280, yv3320, dg, dh, ea)
new_esEs17(Right(yv3280), Right(yv3320), fa, app(app(app(ty_@3, bfe), bff), bfg)) → new_esEs16(yv3280, yv3320, bfe, bff, bfg)
new_esEs4(yv328, yv332, ty_Char) → new_esEs9(yv328, yv332)
new_esEs16(@3(yv3280, yv3281, yv3282), @3(yv3320, yv3321, yv3322), ef, eg, eh) → new_asAs(new_esEs22(yv3280, yv3320, ef), new_asAs(new_esEs23(yv3281, yv3321, eg), new_esEs24(yv3282, yv3322, eh)))
new_esEs22(yv3280, yv3320, app(ty_[], fh)) → new_esEs15(yv3280, yv3320, fh)
new_esEs5(Just(yv3280), Just(yv3320), app(app(ty_@2, bg), bh)) → new_esEs14(yv3280, yv3320, bg, bh)
new_esEs11(False, True) → False
new_esEs11(True, False) → False
new_esEs21(yv3280, yv3320, ty_Int) → new_esEs18(yv3280, yv3320)
new_esEs18(yv328, yv332) → new_primEqInt(yv328, yv332)
new_esEs15([], :(yv3320, yv3321), da) → False
new_esEs15(:(yv3280, yv3281), [], da) → False
new_esEs17(Right(yv3280), Right(yv3320), fa, ty_Float) → new_esEs8(yv3280, yv3320)
new_esEs26(yv3281, yv3321, app(app(ty_@2, bcf), bcg)) → new_esEs14(yv3281, yv3321, bcf, bcg)
new_esEs21(yv3280, yv3320, ty_Char) → new_esEs9(yv3280, yv3320)
new_esEs25(yv3280, yv3320, ty_Double) → new_esEs10(yv3280, yv3320)
new_esEs21(yv3280, yv3320, ty_Bool) → new_esEs11(yv3280, yv3320)
new_esEs26(yv3281, yv3321, ty_Bool) → new_esEs11(yv3281, yv3321)
new_esEs17(Left(yv3280), Left(yv3320), app(ty_[], beb), fb) → new_esEs15(yv3280, yv3320, beb)
new_esEs5(Just(yv3280), Just(yv3320), ty_Double) → new_esEs10(yv3280, yv3320)
new_esEs26(yv3281, yv3321, ty_@0) → new_esEs6(yv3281, yv3321)
new_esEs22(yv3280, yv3320, app(ty_Ratio, fc)) → new_esEs7(yv3280, yv3320, fc)
new_sr(Neg(yv32810), Neg(yv33210)) → Pos(new_primMulNat0(yv32810, yv33210))
new_esEs12(LT, LT) → True
new_esEs17(Right(yv3280), Right(yv3320), fa, ty_Integer) → new_esEs13(yv3280, yv3320)
new_esEs4(yv328, yv332, ty_Float) → new_esEs8(yv328, yv332)
new_esEs24(yv3282, yv3322, app(app(ty_Either, bah), bba)) → new_esEs17(yv3282, yv3322, bah, bba)
new_esEs17(Left(yv3280), Left(yv3320), ty_Double, fb) → new_esEs10(yv3280, yv3320)
new_esEs25(yv3280, yv3320, app(app(ty_Either, bcb), bcc)) → new_esEs17(yv3280, yv3320, bcb, bcc)
new_asAs(False, yv359) → False
new_sr(Pos(yv32810), Pos(yv33210)) → Pos(new_primMulNat0(yv32810, yv33210))
new_esEs22(yv3280, yv3320, ty_Int) → new_esEs18(yv3280, yv3320)
new_esEs5(Just(yv3280), Just(yv3320), ty_Int) → new_esEs18(yv3280, yv3320)
new_esEs22(yv3280, yv3320, ty_@0) → new_esEs6(yv3280, yv3320)
new_primEqNat0(Zero, Zero) → True
new_esEs19(yv3280, yv3320, ty_Integer) → new_esEs13(yv3280, yv3320)
new_esEs17(Right(yv3280), Right(yv3320), fa, ty_Bool) → new_esEs11(yv3280, yv3320)
new_esEs26(yv3281, yv3321, ty_Float) → new_esEs8(yv3281, yv3321)
new_primMulNat0(Succ(yv328100), Zero) → Zero
new_primMulNat0(Zero, Succ(yv332100)) → Zero
new_esEs17(Left(yv3280), Left(yv3320), app(app(app(ty_@3, bec), bed), bee), fb) → new_esEs16(yv3280, yv3320, bec, bed, bee)
new_esEs26(yv3281, yv3321, ty_Integer) → new_esEs13(yv3281, yv3321)
new_primMulNat0(Succ(yv328100), Succ(yv332100)) → new_primPlusNat1(new_primMulNat0(yv328100, Succ(yv332100)), yv332100)
new_esEs23(yv3281, yv3321, ty_Ordering) → new_esEs12(yv3281, yv3321)
new_esEs17(Left(yv3280), Left(yv3320), app(ty_Ratio, bdf), fb) → new_esEs7(yv3280, yv3320, bdf)
new_esEs4(yv328, yv332, ty_Double) → new_esEs10(yv328, yv332)
new_esEs25(yv3280, yv3320, ty_Integer) → new_esEs13(yv3280, yv3320)
new_esEs11(True, True) → True
new_esEs23(yv3281, yv3321, app(ty_Maybe, gg)) → new_esEs5(yv3281, yv3321, gg)
new_esEs25(yv3280, yv3320, app(ty_[], bbf)) → new_esEs15(yv3280, yv3320, bbf)
new_esEs23(yv3281, yv3321, app(ty_[], hb)) → new_esEs15(yv3281, yv3321, hb)
new_esEs17(Left(yv3280), Left(yv3320), ty_Int, fb) → new_esEs18(yv3280, yv3320)
new_esEs23(yv3281, yv3321, ty_Char) → new_esEs9(yv3281, yv3321)
new_esEs17(Right(yv3280), Right(yv3320), fa, app(app(ty_@2, bfb), bfc)) → new_esEs14(yv3280, yv3320, bfb, bfc)
new_esEs26(yv3281, yv3321, ty_Double) → new_esEs10(yv3281, yv3321)
new_esEs22(yv3280, yv3320, ty_Float) → new_esEs8(yv3280, yv3320)
new_esEs5(Just(yv3280), Nothing, bd) → False
new_esEs5(Nothing, Just(yv3320), bd) → False
new_esEs26(yv3281, yv3321, app(ty_[], bch)) → new_esEs15(yv3281, yv3321, bch)
new_esEs13(Integer(yv3280), Integer(yv3320)) → new_primEqInt(yv3280, yv3320)
new_esEs25(yv3280, yv3320, ty_Ordering) → new_esEs12(yv3280, yv3320)
new_esEs5(Just(yv3280), Just(yv3320), app(app(app(ty_@3, cb), cc), cd)) → new_esEs16(yv3280, yv3320, cb, cc, cd)
new_primEqInt(Neg(Succ(yv32800)), Neg(Succ(yv33200))) → new_primEqNat0(yv32800, yv33200)
new_esEs17(Right(yv3280), Right(yv3320), fa, ty_@0) → new_esEs6(yv3280, yv3320)
new_esEs25(yv3280, yv3320, ty_Bool) → new_esEs11(yv3280, yv3320)
new_esEs6(@0, @0) → True
new_esEs25(yv3280, yv3320, ty_@0) → new_esEs6(yv3280, yv3320)
new_esEs23(yv3281, yv3321, app(ty_Ratio, gf)) → new_esEs7(yv3281, yv3321, gf)
new_esEs17(Right(yv3280), Right(yv3320), fa, app(app(ty_Either, bfh), bga)) → new_esEs17(yv3280, yv3320, bfh, bga)
new_esEs23(yv3281, yv3321, app(app(ty_Either, hf), hg)) → new_esEs17(yv3281, yv3321, hf, hg)
new_esEs8(Float(yv3280, yv3281), Float(yv3320, yv3321)) → new_esEs18(new_sr(yv3280, yv3320), new_sr(yv3281, yv3321))
new_esEs26(yv3281, yv3321, app(app(ty_Either, bdd), bde)) → new_esEs17(yv3281, yv3321, bdd, bde)
new_esEs17(Left(yv3280), Left(yv3320), ty_Bool, fb) → new_esEs11(yv3280, yv3320)
new_esEs12(EQ, LT) → False
new_esEs12(LT, EQ) → False
new_esEs5(Just(yv3280), Just(yv3320), ty_Ordering) → new_esEs12(yv3280, yv3320)
new_esEs25(yv3280, yv3320, ty_Int) → new_esEs18(yv3280, yv3320)
new_esEs23(yv3281, yv3321, ty_Double) → new_esEs10(yv3281, yv3321)
new_primEqInt(Neg(Zero), Neg(Zero)) → True
new_esEs25(yv3280, yv3320, app(ty_Ratio, bbb)) → new_esEs7(yv3280, yv3320, bbb)
new_esEs5(Nothing, Nothing, bd) → True
new_esEs26(yv3281, yv3321, app(app(app(ty_@3, bda), bdb), bdc)) → new_esEs16(yv3281, yv3321, bda, bdb, bdc)
new_esEs12(GT, GT) → True
new_primEqInt(Neg(Succ(yv32800)), Neg(Zero)) → False
new_primEqInt(Neg(Zero), Neg(Succ(yv33200))) → False
new_esEs26(yv3281, yv3321, ty_Char) → new_esEs9(yv3281, yv3321)
new_primPlusNat1(Zero, yv332100) → Succ(yv332100)
new_esEs21(yv3280, yv3320, ty_Float) → new_esEs8(yv3280, yv3320)
new_esEs23(yv3281, yv3321, ty_Float) → new_esEs8(yv3281, yv3321)
new_esEs9(Char(yv3280), Char(yv3320)) → new_primEqNat0(yv3280, yv3320)
new_esEs22(yv3280, yv3320, app(ty_Maybe, fd)) → new_esEs5(yv3280, yv3320, fd)
new_primPlusNat0(Succ(yv36000), Succ(yv3321000)) → Succ(Succ(new_primPlusNat0(yv36000, yv3321000)))
new_esEs21(yv3280, yv3320, app(ty_Maybe, dc)) → new_esEs5(yv3280, yv3320, dc)
new_esEs10(Double(yv3280, yv3281), Double(yv3320, yv3321)) → new_esEs18(new_sr(yv3280, yv3320), new_sr(yv3281, yv3321))
new_esEs17(Right(yv3280), Right(yv3320), fa, app(ty_[], bfd)) → new_esEs15(yv3280, yv3320, bfd)
new_esEs24(yv3282, yv3322, ty_Float) → new_esEs8(yv3282, yv3322)
new_esEs4(yv328, yv332, app(app(ty_Either, fa), fb)) → new_esEs17(yv328, yv332, fa, fb)
new_esEs14(@2(yv3280, yv3281), @2(yv3320, yv3321), ed, ee) → new_asAs(new_esEs25(yv3280, yv3320, ed), new_esEs26(yv3281, yv3321, ee))
new_asAs(True, yv359) → yv359
new_esEs17(Left(yv3280), Left(yv3320), ty_@0, fb) → new_esEs6(yv3280, yv3320)
new_esEs17(Right(yv3280), Right(yv3320), fa, app(ty_Ratio, beh)) → new_esEs7(yv3280, yv3320, beh)
new_esEs11(False, False) → True
new_primEqInt(Pos(Succ(yv32800)), Pos(Succ(yv33200))) → new_primEqNat0(yv32800, yv33200)
new_esEs7(:%(yv3280, yv3281), :%(yv3320, yv3321), cg) → new_asAs(new_esEs19(yv3280, yv3320, cg), new_esEs20(yv3281, yv3321, cg))
new_esEs25(yv3280, yv3320, app(ty_Maybe, bbc)) → new_esEs5(yv3280, yv3320, bbc)
new_esEs17(Left(yv3280), Left(yv3320), app(ty_Maybe, bdg), fb) → new_esEs5(yv3280, yv3320, bdg)
new_esEs5(Just(yv3280), Just(yv3320), ty_Bool) → new_esEs11(yv3280, yv3320)
new_esEs24(yv3282, yv3322, ty_Int) → new_esEs18(yv3282, yv3322)
new_esEs5(Just(yv3280), Just(yv3320), app(app(ty_Either, ce), cf)) → new_esEs17(yv3280, yv3320, ce, cf)
new_esEs4(yv328, yv332, app(ty_Ratio, cg)) → new_esEs7(yv328, yv332, cg)
new_primEqNat0(Succ(yv32800), Succ(yv33200)) → new_primEqNat0(yv32800, yv33200)
new_esEs22(yv3280, yv3320, app(app(app(ty_@3, ga), gb), gc)) → new_esEs16(yv3280, yv3320, ga, gb, gc)
new_esEs26(yv3281, yv3321, ty_Ordering) → new_esEs12(yv3281, yv3321)
new_esEs17(Right(yv3280), Right(yv3320), fa, app(ty_Maybe, bfa)) → new_esEs5(yv3280, yv3320, bfa)
new_esEs22(yv3280, yv3320, ty_Double) → new_esEs10(yv3280, yv3320)
new_esEs23(yv3281, yv3321, app(app(ty_@2, gh), ha)) → new_esEs14(yv3281, yv3321, gh, ha)
new_esEs24(yv3282, yv3322, ty_Bool) → new_esEs11(yv3282, yv3322)
new_esEs21(yv3280, yv3320, app(ty_Ratio, db)) → new_esEs7(yv3280, yv3320, db)
new_esEs12(EQ, EQ) → True
new_esEs4(yv328, yv332, app(app(ty_@2, ed), ee)) → new_esEs14(yv328, yv332, ed, ee)
new_esEs24(yv3282, yv3322, app(ty_[], bad)) → new_esEs15(yv3282, yv3322, bad)
new_esEs15([], [], da) → True
new_esEs25(yv3280, yv3320, ty_Char) → new_esEs9(yv3280, yv3320)
new_primEqInt(Pos(Succ(yv32800)), Pos(Zero)) → False
new_primEqInt(Pos(Zero), Pos(Succ(yv33200))) → False
new_esEs22(yv3280, yv3320, ty_Integer) → new_esEs13(yv3280, yv3320)
new_esEs22(yv3280, yv3320, app(app(ty_Either, gd), ge)) → new_esEs17(yv3280, yv3320, gd, ge)
new_esEs17(Left(yv3280), Left(yv3320), ty_Integer, fb) → new_esEs13(yv3280, yv3320)
new_primEqInt(Pos(Zero), Neg(Zero)) → True
new_primEqInt(Neg(Zero), Pos(Zero)) → True
new_primPlusNat0(Succ(yv36000), Zero) → Succ(yv36000)
new_primPlusNat0(Zero, Succ(yv3321000)) → Succ(yv3321000)
new_esEs5(Just(yv3280), Just(yv3320), ty_Integer) → new_esEs13(yv3280, yv3320)

The set Q consists of the following terms:

new_esEs17(Right(x0), Right(x1), x2, app(ty_[], x3))
new_esEs17(Right(x0), Right(x1), x2, ty_Ordering)
new_esEs21(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primEqInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_esEs5(Just(x0), Just(x1), ty_Ordering)
new_esEs17(Left(x0), Left(x1), ty_@0, x2)
new_esEs11(True, True)
new_esEs17(Right(x0), Right(x1), x2, app(app(app(ty_@3, x3), x4), x5))
new_esEs26(x0, x1, ty_@0)
new_esEs19(x0, x1, ty_Integer)
new_esEs17(Left(x0), Left(x1), app(ty_Ratio, x2), x3)
new_esEs22(x0, x1, ty_Float)
new_esEs24(x0, x1, ty_@0)
new_primEqInt(Pos(Zero), Neg(Zero))
new_primEqInt(Neg(Zero), Pos(Zero))
new_esEs23(x0, x1, ty_Int)
new_esEs21(x0, x1, ty_Char)
new_esEs17(Left(x0), Left(x1), ty_Bool, x2)
new_esEs19(x0, x1, ty_Int)
new_esEs4(x0, x1, ty_Ordering)
new_esEs23(x0, x1, ty_Bool)
new_sr(Neg(x0), Pos(x1))
new_sr(Pos(x0), Neg(x1))
new_esEs17(Left(x0), Left(x1), ty_Integer, x2)
new_esEs24(x0, x1, app(ty_Maybe, x2))
new_esEs5(Just(x0), Just(x1), ty_Float)
new_esEs13(Integer(x0), Integer(x1))
new_esEs22(x0, x1, app(app(ty_Either, x2), x3))
new_esEs23(x0, x1, ty_Float)
new_esEs24(x0, x1, app(ty_[], x2))
new_esEs23(x0, x1, ty_Char)
new_esEs23(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primEqInt(Neg(Zero), Neg(Zero))
new_esEs24(x0, x1, app(app(ty_@2, x2), x3))
new_esEs22(x0, x1, ty_@0)
new_esEs17(Right(x0), Right(x1), x2, ty_Integer)
new_esEs4(x0, x1, ty_Float)
new_esEs25(x0, x1, ty_Double)
new_esEs5(Just(x0), Just(x1), ty_Bool)
new_esEs26(x0, x1, ty_Double)
new_esEs15(:(x0, x1), [], x2)
new_esEs11(False, True)
new_esEs11(True, False)
new_esEs26(x0, x1, app(ty_Maybe, x2))
new_primMulNat0(Succ(x0), Zero)
new_esEs17(Left(x0), Left(x1), app(ty_Maybe, x2), x3)
new_esEs21(x0, x1, ty_@0)
new_esEs12(EQ, GT)
new_esEs12(GT, EQ)
new_esEs5(Just(x0), Just(x1), app(ty_[], x2))
new_esEs23(x0, x1, app(ty_[], x2))
new_esEs17(Right(x0), Right(x1), x2, app(ty_Ratio, x3))
new_esEs26(x0, x1, ty_Float)
new_esEs22(x0, x1, app(ty_[], x2))
new_primEqNat0(Zero, Succ(x0))
new_esEs4(x0, x1, ty_Int)
new_esEs4(x0, x1, app(app(ty_@2, x2), x3))
new_esEs21(x0, x1, app(ty_Ratio, x2))
new_esEs12(GT, GT)
new_esEs16(@3(x0, x1, x2), @3(x3, x4, x5), x6, x7, x8)
new_esEs26(x0, x1, app(ty_[], x2))
new_esEs20(x0, x1, ty_Integer)
new_esEs17(Left(x0), Left(x1), ty_Double, x2)
new_esEs21(x0, x1, ty_Ordering)
new_primMulNat0(Succ(x0), Succ(x1))
new_esEs5(Just(x0), Nothing, x1)
new_esEs25(x0, x1, ty_Int)
new_esEs17(Right(x0), Right(x1), x2, ty_Int)
new_esEs17(Left(x0), Left(x1), app(app(app(ty_@3, x2), x3), x4), x5)
new_esEs5(Just(x0), Just(x1), app(app(ty_Either, x2), x3))
new_esEs26(x0, x1, app(app(ty_Either, x2), x3))
new_esEs25(x0, x1, app(app(ty_@2, x2), x3))
new_esEs25(x0, x1, app(ty_Maybe, x2))
new_primPlusNat0(Succ(x0), Zero)
new_esEs7(:%(x0, x1), :%(x2, x3), x4)
new_esEs17(Right(x0), Right(x1), x2, ty_@0)
new_esEs10(Double(x0, x1), Double(x2, x3))
new_esEs21(x0, x1, ty_Bool)
new_esEs24(x0, x1, app(ty_Ratio, x2))
new_esEs22(x0, x1, ty_Double)
new_esEs4(x0, x1, ty_Double)
new_esEs4(x0, x1, app(ty_[], x2))
new_esEs4(x0, x1, ty_Char)
new_esEs21(x0, x1, app(app(ty_Either, x2), x3))
new_esEs25(x0, x1, ty_Ordering)
new_esEs24(x0, x1, ty_Int)
new_esEs24(x0, x1, ty_Integer)
new_esEs25(x0, x1, ty_@0)
new_esEs24(x0, x1, ty_Float)
new_primPlusNat1(Succ(x0), x1)
new_esEs21(x0, x1, ty_Double)
new_primEqNat0(Zero, Zero)
new_esEs15([], [], x0)
new_esEs17(Right(x0), Right(x1), x2, ty_Bool)
new_esEs17(Right(x0), Right(x1), x2, ty_Float)
new_esEs5(Just(x0), Just(x1), ty_Int)
new_esEs17(Right(x0), Right(x1), x2, ty_Char)
new_esEs5(Just(x0), Just(x1), app(ty_Maybe, x2))
new_esEs26(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs22(x0, x1, ty_Integer)
new_esEs17(Left(x0), Left(x1), app(app(ty_Either, x2), x3), x4)
new_esEs17(Left(x0), Left(x1), ty_Int, x2)
new_sr(Pos(x0), Pos(x1))
new_esEs26(x0, x1, ty_Char)
new_esEs24(x0, x1, app(app(ty_Either, x2), x3))
new_asAs(False, x0)
new_primMulNat0(Zero, Zero)
new_esEs25(x0, x1, app(ty_Ratio, x2))
new_primMulNat0(Zero, Succ(x0))
new_esEs17(Right(x0), Right(x1), x2, app(app(ty_@2, x3), x4))
new_esEs22(x0, x1, ty_Int)
new_esEs24(x0, x1, ty_Bool)
new_esEs26(x0, x1, app(ty_Ratio, x2))
new_esEs4(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs21(x0, x1, app(ty_Maybe, x2))
new_esEs26(x0, x1, ty_Integer)
new_esEs4(x0, x1, ty_Bool)
new_esEs15([], :(x0, x1), x2)
new_esEs23(x0, x1, ty_Ordering)
new_esEs4(x0, x1, ty_Integer)
new_esEs17(Left(x0), Left(x1), ty_Ordering, x2)
new_esEs25(x0, x1, ty_Float)
new_esEs25(x0, x1, ty_Char)
new_esEs24(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs22(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs24(x0, x1, ty_Double)
new_esEs17(Left(x0), Left(x1), app(ty_[], x2), x3)
new_esEs22(x0, x1, app(app(ty_@2, x2), x3))
new_esEs21(x0, x1, ty_Int)
new_primEqInt(Neg(Zero), Pos(Succ(x0)))
new_primEqInt(Pos(Zero), Neg(Succ(x0)))
new_esEs24(x0, x1, ty_Ordering)
new_primEqInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_esEs4(x0, x1, app(ty_Ratio, x2))
new_esEs22(x0, x1, ty_Ordering)
new_esEs25(x0, x1, ty_Bool)
new_esEs9(Char(x0), Char(x1))
new_primPlusNat0(Zero, Succ(x0))
new_esEs8(Float(x0, x1), Float(x2, x3))
new_esEs26(x0, x1, ty_Int)
new_esEs23(x0, x1, app(ty_Ratio, x2))
new_primEqInt(Neg(Succ(x0)), Neg(Zero))
new_esEs22(x0, x1, ty_Char)
new_primEqInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(x0, x1, ty_Ordering)
new_esEs23(x0, x1, ty_@0)
new_esEs17(Right(x0), Right(x1), x2, app(ty_Maybe, x3))
new_esEs21(x0, x1, app(ty_[], x2))
new_esEs23(x0, x1, ty_Double)
new_esEs5(Just(x0), Just(x1), ty_@0)
new_primEqNat0(Succ(x0), Succ(x1))
new_esEs21(x0, x1, ty_Integer)
new_esEs25(x0, x1, app(ty_[], x2))
new_esEs5(Just(x0), Just(x1), ty_Char)
new_esEs6(@0, @0)
new_sr(Neg(x0), Neg(x1))
new_asAs(True, x0)
new_esEs11(False, False)
new_esEs25(x0, x1, ty_Integer)
new_esEs17(Right(x0), Right(x1), x2, app(app(ty_Either, x3), x4))
new_primEqInt(Pos(Succ(x0)), Pos(Zero))
new_esEs5(Just(x0), Just(x1), ty_Double)
new_esEs21(x0, x1, ty_Float)
new_primEqInt(Pos(Zero), Pos(Succ(x0)))
new_esEs17(Left(x0), Left(x1), app(app(ty_@2, x2), x3), x4)
new_esEs22(x0, x1, app(ty_Maybe, x2))
new_esEs5(Just(x0), Just(x1), ty_Integer)
new_esEs5(Just(x0), Just(x1), app(app(ty_@2, x2), x3))
new_esEs17(Left(x0), Left(x1), ty_Float, x2)
new_esEs12(LT, EQ)
new_esEs12(EQ, LT)
new_esEs21(x0, x1, app(app(ty_@2, x2), x3))
new_primPlusNat0(Succ(x0), Succ(x1))
new_esEs5(Just(x0), Just(x1), app(app(app(ty_@3, x2), x3), x4))
new_esEs12(EQ, EQ)
new_primPlusNat0(Zero, Zero)
new_esEs26(x0, x1, ty_Bool)
new_primEqNat0(Succ(x0), Zero)
new_esEs5(Nothing, Nothing, x0)
new_esEs25(x0, x1, app(app(ty_Either, x2), x3))
new_primEqInt(Pos(Zero), Pos(Zero))
new_esEs14(@2(x0, x1), @2(x2, x3), x4, x5)
new_primPlusNat1(Zero, x0)
new_esEs24(x0, x1, ty_Char)
new_esEs20(x0, x1, ty_Int)
new_esEs23(x0, x1, ty_Integer)
new_esEs25(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs17(Left(x0), Left(x1), ty_Char, x2)
new_primEqInt(Neg(Succ(x0)), Pos(x1))
new_primEqInt(Pos(Succ(x0)), Neg(x1))
new_esEs22(x0, x1, app(ty_Ratio, x2))
new_esEs12(LT, LT)
new_esEs23(x0, x1, app(app(ty_@2, x2), x3))
new_esEs5(Nothing, Just(x0), x1)
new_esEs12(LT, GT)
new_esEs12(GT, LT)
new_esEs4(x0, x1, app(ty_Maybe, x2))
new_esEs18(x0, x1)
new_esEs4(x0, x1, app(app(ty_Either, x2), x3))
new_esEs15(:(x0, x1), :(x2, x3), x4)
new_esEs26(x0, x1, app(app(ty_@2, x2), x3))
new_esEs17(Right(x0), Right(x1), x2, ty_Double)
new_esEs23(x0, x1, app(app(ty_Either, x2), x3))
new_esEs23(x0, x1, app(ty_Maybe, x2))
new_esEs5(Just(x0), Just(x1), app(ty_Ratio, x2))
new_esEs17(Right(x0), Left(x1), x2, x3)
new_esEs17(Left(x0), Right(x1), x2, x3)
new_esEs22(x0, x1, ty_Bool)
new_esEs4(x0, x1, ty_@0)

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: